/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package groupe;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import java.io.*;

import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.*;
import java.text.DecimalFormat;
import java.util.*;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 *
 * @author ter Murea Victor
 */
public class Operations {
    static Element racine;
    public  int num=1;

        public static Element getEvaluation(Element valeur, Element valeur2, String type, String name, int tot, int taille){
        NodeList listEvaluations = valeur.getElementsByTagName(name);
        NodeList listEvaluations2 = valeur2.getElementsByTagName(name);
        double d=0;
        if (listEvaluations.getLength()!=0){
            /*Element critere = getCritere(Integer.parseInt(type));
            if(critere!=null){
                if(critere.getElementsByTagName("numerique").getLength()>0){*/
                if(type.equals("0")){
                System.out.println("evaluations  "+listEvaluations.getLength());
                    for (int i=0; i<listEvaluations.getLength(); i++){
                        Element evaluation = (Element) listEvaluations.item(i);
                        Element evaluation2 = (Element) listEvaluations2.item(i);
                        String date = evaluation.getAttribute("date");
                        String source = evaluation.getAttribute("source");
                       // String texte = evaluation.getTextContent();
                        System.out.println("numeroter "+evaluation.getTextContent());
                        //evaluation.setTextContent(texte+" ivangenio ");
                        Double moyenne,moyenne_part;
                        moyenne_part=Double.parseDouble((evaluation2.getTextContent()));
                        moyenne=(Double) ((Double.parseDouble((evaluation.getTextContent()))+moyenne_part*(tot-1))/tot);
                        //evaluation2.setTextContent(String.valueOf(Integer.parseInt(texte)+Integer.parseInt((evaluation.getTextContent()))));
                        /*DecimalFormat df = new DecimalFormat ( ) ;
                        df.setMaximumFractionDigits ( 2 ) ;
                        df.set*/
                        System.out.println(taille+" ---- "+tot);
                        if (taille==tot)
                        {DecimalFormat df = new DecimalFormat ( ) ;
                          df.setMaximumFractionDigits ( 2 ) ;
                          evaluation2.setTextContent(df.format(moyenne).replace(",", "."));
                        }else
                        { evaluation2.setTextContent(String.valueOf(moyenne));
                        }
                    }
                   }

          
        }
       
    return valeur;
    }

    public static Element traiterComposante(Element composante,Element composante2,int tot,int taille) {

          Node tempo = composante.getFirstChild();
          Node tempo2 = composante2.getFirstChild();
        int test=0;
        String type="";
       System.out.println(" ---->>> nom: "+composante.getAttribute("nom")+" : "+composante.getChildNodes().getLength());
        while(/*!tempo.equals(sousComposante.getLastChild())*/test<composante.getChildNodes().getLength()){
            System.out.println("    "+tempo.getNodeName());
            if (tempo.getNodeName().equals("commentaires")){
                getEvaluation((Element) tempo,(Element) tempo2,type, "commentaire",tot,taille);
            
            }else if (tempo.getNodeName().equals("valeur")){
                type = ((Element)tempo).getAttribute("id_echelle");
                getEvaluation((Element) tempo,(Element) tempo2, type, "evaluation",tot,taille);
            } else if (tempo.getNodeName().equals("sous_composante")){
                Element nodeTmp = traiterSousComposante((Element)tempo,(Element)tempo2,tot,taille);
                
            }
            tempo =    tempo.getNextSibling();
            tempo2 =    tempo2.getNextSibling();
            test++;
        }
      return composante;
    }

    private static Element traiterSousComposante(Element sousComposante, Element sousComposante2,int tot, int taille){
       
        Node tempo2=sousComposante2.getFirstChild();
        Node tempo = sousComposante.getFirstChild();
        int test=0;
      String type="";
        System.out.println(" ---->>> nom: "+sousComposante.getAttribute("nom")+" : "+sousComposante.getChildNodes().getLength());
        while(/*!tempo.equals(sousComposante.getLastChild())*/test<sousComposante.getChildNodes().getLength()){
            System.out.println("    "+tempo.getNodeName());
            if (tempo.getNodeName().equals("commentaires")){
            getEvaluation((Element) tempo,(Element) tempo2,type, "commentaire",tot,taille);
            }else if (tempo.getNodeName().equals("valeur")){
                type = ((Element)tempo).getAttribute("id_echelle");
                getEvaluation((Element) tempo,(Element) tempo2,type, "evaluation",tot,taille);
            } else if (tempo.getNodeName().equals("sous_composante")){
                Element nodeTmp = traiterSousComposante((Element)tempo,(Element)tempo2,tot,taille);
              
            }
            tempo =    tempo.getNextSibling();
            tempo2 =    tempo2.getNextSibling();
            test++;
        }

     return sousComposante;
    }


    public static  Element [] createTree(NodeList listArbreDesComposantes, NodeList listArbreDesComposantes2, String nom,int tot,int taille){
     //  DefaultMutableTreeNode tree = new DefaultMutableTreeNode(nom,true);

       Element [] arbre = new Element[listArbreDesComposantes.getLength()];
       Element [] arbre2 = new Element[listArbreDesComposantes.getLength()];
        for (int i=0; i<listArbreDesComposantes.getLength();i++){
            //Recuperer l'arbre des composantes
            arbre[i] = (Element) listArbreDesComposantes.item(i);
             arbre2[i] = (Element) listArbreDesComposantes2.item(i);
            // Recuperer la liste des composantes
            NodeList listComposant = arbre[i].getElementsByTagName("composante");
            NodeList listComposant2 = arbre2[i].getElementsByTagName("composante");

            for (int j=0; j<listComposant.getLength(); j++){

                Element composant = (Element) listComposant.item(j);
                Element composant2 = (Element) listComposant2.item(j);
                
                  Element tmp =traiterComposante(composant,composant2,tot,taille);
      }
        }return arbre;
    }


public void ajouter(String nomGroupe, Element brique, String TotalGroupe, String Temporaire,Document document, Document document2,int tot, int taille) throws ParserConfigurationException, SAXException, IOException, TransformerConfigurationException, TransformerException{
                       num=tot;
                       
        String nom = brique.getAttribute("nom");
      
      NodeList listArbreDesComposantes = document.getElementsByTagName("arbre_des_composantes");
      NodeList listArbreDesComposantes2 = document2.getElementsByTagName("arbre_des_composantes");
      Element [] n1 = new Element[listArbreDesComposantes.getLength()];
   
       n1= Operations.createTree(listArbreDesComposantes,listArbreDesComposantes2, nom, tot, taille);

       Element root = document2.getDocumentElement();
       root.setAttribute("prenom_eleve", nomGroupe);
        transformerXml(document2, TotalGroupe);
    }

public static void transformerXml(Document document, String fichier) {
        try {
            // Création de la source DOM
            Source source = new DOMSource(document);

            // Création du fichier de sortie
            File file = new File(fichier);
            Result resultat = new StreamResult(fichier);

            // Configuration du transformer
            TransformerFactory fabrique = TransformerFactory.newInstance();
            Transformer transformer = fabrique.newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

            // Transformation
            transformer.transform(source, resultat);
        }catch(Exception e){
        	e.printStackTrace();
        }
    }

    private static Element getCritere(int type) throws UnsupportedEncodingException, ParserConfigurationException, SAXException, IOException{
        Element rootEl = Utility.getElement(Utility.getPath(Utility.class, "/Fichiers systeme/Parametres/echelle.xml"));
        NodeList listCriteres = rootEl.getElementsByTagName("critere");
        for (int i=0; i<listCriteres.getLength();i++){
            if (Integer.parseInt(((Element)listCriteres.item(i)).getAttribute("id").toString())==type){
                return (Element)listCriteres.item(i);
            }
        }
        return null;
    }

}
